{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ML_in_Finance-2D-CNNs\n",
    "# Author: Matthew Dixon\n",
    "# Version: 1.0 (28.4.2020)\n",
    "# License: MIT\n",
    "# Email: matthew.dixon@iit.edu\n",
    "# Notes: tested on Mac OS X running Python 3.6.9 with the following packages:\n",
    "# tensorflow=2.0.0, keras=2.3.1, scikit-learn=0.22.1, numpy=1.18.1, matplotlib=3.1.3\n",
    "# Citation: Please cite the following reference if this notebook is used for research purposes:\n",
    "# Bilokon P., Dixon M.F. and Halperin I., Machine Learning in Finance: From Theory to Practice, Springer Graduate Textbook Series, 2020. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using TensorFlow backend.\n"
     ]
    }
   ],
   "source": [
    "from keras import backend as K\n",
    "from keras.layers.core import Dense, Dropout, Activation, Flatten\n",
    "from keras.layers import Conv2D, MaxPooling2D\n",
    "from keras.models import Sequential\n",
    "from keras.losses import categorical_crossentropy\n",
    "from keras.optimizers import Adadelta\n",
    "from keras.utils import to_categorical\n",
    "from keras.datasets import mnist\n",
    "\n",
    "import numpy as np\n",
    "\n",
    "from sklearn.metrics import classification_report\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.cm as cm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Image Classification with 2D Convolutional Neural Networks"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data Preparation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First, load the dataset:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "batch_size = 128\n",
    "epochs = 1\n",
    "\n",
    "num_classes = 10\n",
    "\n",
    "# input image dimensions\n",
    "img_rows, img_cols = 28, 28\n",
    "\n",
    "# the data, split between train and test sets\n",
    "(x_train, labels_train), (x_test, labels_test) = mnist.load_data()\n",
    "\n",
    "\n",
    "print((img_rows, img_cols) == x_train.shape[1:] == x_test.shape[1:])\n",
    "print(num_classes == len(np.unique(labels_train)) == len(np.unique(labels_test)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x_train shape: (60000, 28, 28)\n",
      "x_test shape: (10000, 28, 28)\n"
     ]
    }
   ],
   "source": [
    "print('x_train shape:', x_train.shape)\n",
    "print('x_test shape:', x_test.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then reshape the input arrays to add a dimension to their `shape` representing the number of colour channels, which for the grayscale images of the MNIST dataset is 1\n",
    "\n",
    "The `if...else` statement is necessary for compatibility reasons, as different keras backends take image data in different formats: the colour channels may need to be either along the dimension before, or the dimension after, the width and height dimensions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "if K.image_data_format() == 'channels_first':\n",
    "    x_train = x_train.reshape(x_train.shape[0], 1, img_rows, img_cols)\n",
    "    x_test = x_test.reshape(x_test.shape[0], 1, img_rows, img_cols)\n",
    "    input_shape = (1, img_rows, img_cols)\n",
    "else:\n",
    "    x_train = x_train.reshape(x_train.shape[0], img_rows, img_cols, 1)\n",
    "    x_test = x_test.reshape(x_test.shape[0], img_rows, img_cols, 1)\n",
    "    input_shape = (img_rows, img_cols, 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can see that the training set has 60,000 observations, and the testing set has 10,000. Each observation is a 28x28 image with one grayscale input channel."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x_train shape: (60000, 28, 28, 1)\n",
      "60000 train samples\n",
      "x_test shape: (10000, 28, 28, 1)\n",
      "10000 test samples\n"
     ]
    }
   ],
   "source": [
    "print('x_train shape:', x_train.shape)\n",
    "print(x_train.shape[0], 'train samples')\n",
    "print('x_test shape:', x_test.shape)\n",
    "print(x_test.shape[0], 'test samples')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We then scale the input data into the interval $[0,1]$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "original range: 0 - 255\n",
      "scaled range: 0.0 - 1.0\n"
     ]
    }
   ],
   "source": [
    "if x_train.max() == 255:\n",
    "    print('original range: {} - {}'.format(x_train.min(), x_train.max()))\n",
    "    \n",
    "    x_train = x_train.astype('float32')\n",
    "    x_test = x_test.astype('float32')\n",
    "\n",
    "    x_train /= 255\n",
    "    x_test /= 255\n",
    "\n",
    "    print('scaled range: {} - {}'.format(x_train.min(), x_train.max()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The output of the neural network will be a vector, with each element corresponding to one of the ten class labels. We therefore convert the class vectors `y_train` and `y_test` to binary class matrices, each row representing the desired output of the model for a member of that class. This is known as **one-hot encoding**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "labels_train.shape: (60000,)\n",
      "labels_test.shape: (10000,)\n",
      "y_train.shape: (60000, 10)\n",
      "y_test.shape: (10000, 10)\n"
     ]
    }
   ],
   "source": [
    "y_train = to_categorical(labels_train, num_classes)\n",
    "y_test = to_categorical(labels_test, num_classes)\n",
    "\n",
    "print('labels_train.shape:', labels_train.shape)    \n",
    "print('labels_test.shape:', labels_test.shape)    \n",
    "print('y_train.shape:', y_train.shape)\n",
    "print('y_test.shape:', y_test.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "label: 8\n",
      "one-hot encoding: [0. 0. 0. 0. 0. 0. 0. 0. 1. 0.]\n"
     ]
    }
   ],
   "source": [
    "i = 34567 # choose a training point\n",
    "print('label:', labels_train[i])\n",
    "print('one-hot encoding:', y_train[i])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Defining the model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We define a typical convolutional architecture: two 2D convolutional layers, followed by a max pooling layer, followed by two dense layers:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = Sequential()\n",
    "\n",
    "# The first layer of the model will learn 32 kernels of size 3x3, \n",
    "# which it will convolve across the input image's two spatial dimensions\n",
    "model.add(Conv2D(filters=32, kernel_size=(3, 3), input_shape=input_shape))\n",
    "\n",
    "# We assign the output of the first convolutional layer to a variable \n",
    "# before adding it to the model so we can access its contents later\n",
    "convout1 = Activation('relu')\n",
    "model.add(convout1)\n",
    "\n",
    "# This is followed by a second convolutional layer, with 64 3x3 kernels\n",
    "model.add(Conv2D(64, (3, 3), activation='relu'))\n",
    "\n",
    "# A max pooling layer performs down-sampling by dividing the input into\n",
    "# rectangular pooling regions, and computing the maximum of each region. \n",
    "model.add(MaxPooling2D(pool_size=(2, 2)))\n",
    "model.add(Dropout(0.25))\n",
    "model.add(Flatten())\n",
    "\n",
    "# Finally two densely connected layers map the feature representations \n",
    "# learned by the convolutional layers to the class labels\n",
    "model.add(Dense(128, activation='relu'))\n",
    "model.add(Dropout(0.5))\n",
    "\n",
    "model.add(Dense(num_classes, activation='softmax'))\n",
    "\n",
    "model.compile(loss=categorical_crossentropy,\n",
    "              optimizer=Adadelta(),\n",
    "              metrics=['accuracy'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential_1\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d_1 (Conv2D)            (None, 26, 26, 32)        320       \n",
      "_________________________________________________________________\n",
      "activation_1 (Activation)    (None, 26, 26, 32)        0         \n",
      "_________________________________________________________________\n",
      "conv2d_2 (Conv2D)            (None, 24, 24, 64)        18496     \n",
      "_________________________________________________________________\n",
      "max_pooling2d_1 (MaxPooling2 (None, 12, 12, 64)        0         \n",
      "_________________________________________________________________\n",
      "dropout_1 (Dropout)          (None, 12, 12, 64)        0         \n",
      "_________________________________________________________________\n",
      "flatten_1 (Flatten)          (None, 9216)              0         \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 128)               1179776   \n",
      "_________________________________________________________________\n",
      "dropout_2 (Dropout)          (None, 128)               0         \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 10)                1290      \n",
      "=================================================================\n",
      "Total params: 1,199,882\n",
      "Trainable params: 1,199,882\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "model.summary()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Above, you can see that the output of every Conv2D and MaxPooling2D layer is a 3D tensor of shape (height, width, number of filters). \n",
    "\n",
    "The number of filters, or output channels, is set by the first argument, `filters`, when instantiating each `Conv2D` layer (e.g., 32 or 64). The width and height dimensions tend to shrink as we go deeper in the network. Typically, as the width and height shrink, we can afford (computationally) to add more filters in each convolutional layer.\n",
    "\n",
    "The width and height are determined by the layer's `input_shape` and `kernel_size`. The tensor contains the filter's activation with its upper left corner at each spatial $\\left(x, y\\right)$ position from `x = 0` to `x = input_width - kernel_width + 1`, and `y = 0` to `y = input_height - kernel_height + 1`, for each of the filters. That is, the activation at every position such that the filter does not extend beyond the edges of the input."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train on 60000 samples, validate on 10000 samples\n",
      "Epoch 1/1\n",
      "60000/60000 [==============================] - 300s 5ms/step - loss: 0.2628 - accuracy: 0.9184 - val_loss: 0.0694 - val_accuracy: 0.9774\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<keras.callbacks.callbacks.History at 0x1a5348e390>"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "batch_size = 128\n",
    "epochs = 1\n",
    "\n",
    "model.fit(x_train, y_train,\n",
    "          batch_size=batch_size,\n",
    "          epochs=epochs,\n",
    "          verbose=1,\n",
    "          validation_data=(x_test, y_test))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test loss: 0.06944611182827502\n",
      "Test accuracy: 0.977400004863739\n"
     ]
    }
   ],
   "source": [
    "score = model.evaluate(x_test, y_test, verbose=0)\n",
    "print('Test loss:', score[0])\n",
    "print('Test accuracy:', score[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can get the outputs for the test points:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_pred = model.predict(x_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Convert the outputs generated from one-hot back into class labels.\n",
    "\n",
    "`numpy.argmax()` returns the index of the maximum value in the array along the specified axis, which is the class label. \n",
    "\n",
    "For the MNIST dataset, conveniently, this is equal to the digit the input has been classified as."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "labels_pred = np.argmax(y_pred, axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "label_activations = np.max(y_pred, axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(10000, 10)\n",
      "(10000,)\n"
     ]
    }
   ],
   "source": [
    "print(np.shape(y_pred)) \n",
    "print(np.shape(labels_pred))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.98      0.99      0.98       980\n",
      "           1       0.99      0.99      0.99      1135\n",
      "           2       0.98      0.96      0.97      1032\n",
      "           3       0.93      0.99      0.96      1010\n",
      "           4       0.99      0.99      0.99       982\n",
      "           5       0.97      0.98      0.97       892\n",
      "           6       0.99      0.97      0.98       958\n",
      "           7       0.98      0.98      0.98      1028\n",
      "           8       0.97      0.97      0.97       974\n",
      "           9       0.99      0.95      0.97      1009\n",
      "\n",
      "    accuracy                           0.98     10000\n",
      "   macro avg       0.98      0.98      0.98     10000\n",
      "weighted avg       0.98      0.98      0.98     10000\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(classification_report(labels_test, labels_pred))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "# utility functions\n",
    "from mpl_toolkits.axes_grid1 import make_axes_locatable\n",
    "\n",
    "def nice_imshow(data, vmin=None, vmax=None):\n",
    "    \"\"\"Wrapper around plt.imshow\"\"\"\n",
    "    ax = plt.gca()\n",
    "    if vmin is None:\n",
    "        vmin = data.min()\n",
    "    if vmax is None:\n",
    "        vmax = data.max()\n",
    "    divider = make_axes_locatable(ax)\n",
    "    cax = divider.append_axes(\"right\", size=\"5%\", pad=0.05)\n",
    "    im = ax.imshow(data, vmin=vmin, vmax=vmax, interpolation='nearest', cmap=plt.cm.binary)\n",
    "    plt.colorbar(im, cax=cax)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Visualize the first layer of convolutions on an input image"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "i = 492 # choose a test point\n",
    "\n",
    "X = x_test[i]\n",
    "title_str = 'input image\\n(label:{}, predicted:{}, activation:{:.3})'\n",
    "plt.title(title_str.format(labels_test[i], labels_pred[i], label_activations[i]))\n",
    "nice_imshow(np.squeeze(X), vmin=0, vmax=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_mosaic(imgs, nrows, ncols, imshape, border=1):\n",
    "    \"\"\"\n",
    "    Given a set of images with all the same shape, makes a\n",
    "    mosaic with nrows and ncols\n",
    "    \"\"\"\n",
    "    nimgs = imgs.shape[3]\n",
    "    \n",
    "    mosaic = np.ma.masked_all((nrows * imshape[0] + (nrows - 1) * border,\n",
    "                            ncols * imshape[1] + (ncols - 1) * border),\n",
    "                            dtype=np.float32)\n",
    "    \n",
    "    paddedh = imshape[0] + border\n",
    "    paddedw = imshape[1] + border\n",
    "    \n",
    "    for i in range(nimgs):\n",
    "        row = int(np.floor(i / ncols))\n",
    "        col = i % ncols\n",
    "        rmin, rmax = (row * paddedh, row * paddedh + imshape[0])\n",
    "        cmin, cmax = (col * paddedw, col * paddedw + imshape[1])\n",
    "        \n",
    "        mosaic[rmin:rmax, cmin:cmax] = imgs[:,:,:,i].reshape(imshape[0],imshape[1])\n",
    "    return mosaic\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Visualising the weights of the first convolutional layer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can visualise the features the first convolutional layer has learned. First they must be retrieved from the trained model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "W shape :  (3, 3, 1, 32)\n"
     ]
    }
   ],
   "source": [
    "W, b = model.layers[0].get_weights()\n",
    "print(\"W shape : \", W.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The weights are the 32 kernels of size 3x3, which generate the feature representation when convolved across the input image."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x1080 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(15, 15))\n",
    "plt.title('conv1 weights')\n",
    "nice_imshow(make_mosaic(W, 6, 6, [3, 3]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# K.learning_phase() is a flag that indicates if the network is in training or\n",
    "# predict phase. It allow layer (e.g. Dropout) to only be applied during training\n",
    "inputs = [K.learning_phase()] + model.inputs\n",
    "_convout1_f = K.function(inputs, [convout1.output])\n",
    "def convout1_f(X):\n",
    "    # The [0] is to disable the training phase flag\n",
    "    return _convout1_f([0] + [X])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also visualise the output of the layer when a given test point is fed through the network. These show the point in terms of the features the model has learned in order to allow the following layers to separate the classes. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "C1 shape :  (1, 26, 26, 32)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/Dez/anaconda3/envs/malfoy/lib/python3.6/site-packages/matplotlib/image.py:414: RuntimeWarning: invalid value encountered in subtract\n",
      "  A_scaled -= a_min\n",
      "/Users/Dez/anaconda3/envs/malfoy/lib/python3.6/site-packages/matplotlib/colors.py:973: RuntimeWarning: overflow encountered in true_divide\n",
      "  resdat /= (vmax - vmin)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x1080 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "i = 4600 # choose a test point\n",
    "\n",
    "# Visualize convolution result (after activation)\n",
    "C1 = convout1_f(x_test[i:i+1])[0]\n",
    "print(\"C1 shape : \", C1.shape)\n",
    "\n",
    "plt.figure(figsize=(15, 15))\n",
    "plt.suptitle('convout1 activation', position=(0.5, 0.9))\n",
    "nice_imshow(make_mosaic(C1, 6, 6, [26, 26]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
